package abs.dao;

import abs.domain.Proveedores;

import java.util.Arrays;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;

import javax.persistence.EntityManager;
import javax.persistence.NoResultException;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;

import org.skyway.spring.util.dao.AbstractJpaDao;

import org.springframework.dao.DataAccessException;

import org.springframework.stereotype.Repository;

import org.springframework.transaction.annotation.Transactional;

/**
 * DAO to manage Proveedores entities.
 * 
 */
@Repository("ProveedoresDAO")
@Transactional
public class ProveedoresDAOImpl extends AbstractJpaDao<Proveedores> implements
		ProveedoresDAO {

	/**
	 * Set of entity classes managed by this DAO.  Typically a DAO manages a single entity.
	 *
	 */
	private final static Set<Class<?>> dataTypes = new HashSet<Class<?>>(Arrays.asList(new Class<?>[] { Proveedores.class }));

	/**
	 * EntityManager injected by Spring for persistence unit absV2
	 *
	 */
	@PersistenceContext(unitName = "absV2")
	private EntityManager entityManager;

	/**
	 * Instantiates a new ProveedoresDAOImpl
	 *
	 */
	public ProveedoresDAOImpl() {
		super();
	}

	/**
	 * Get the entity manager that manages persistence unit 
	 *
	 */
	@Override
	public EntityManager getEntityManager() {
		return entityManager;
	}

	/**
	 * Returns the set of entity classes managed by this DAO.
	 *
	 */
	@Override
	public Set<Class<?>> getTypes() {
		return dataTypes;
	}

	/**
	 * JPQL Query - findAllProveedoress
	 *
	 */
	@Override
	@Transactional
	public Set<Proveedores> findAllProveedoress() throws DataAccessException {

		return findAllProveedoress(-1, -1);
	}

	/**
	 * JPQL Query - findAllProveedoress
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Proveedores> findAllProveedoress(int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findAllProveedoress", startResult, maxRows);
		return new LinkedHashSet<Proveedores>(query.getResultList());
	}

	/**
	 * JPQL Query - findProveedoresByPr100feadAfter
	 *
	 */
	@Override
	@Transactional
	public Set<Proveedores> findProveedoresByPr100feadAfter(java.util.Calendar pr100fead) throws DataAccessException {

		return findProveedoresByPr100feadAfter(pr100fead, -1, -1);
	}

	/**
	 * JPQL Query - findProveedoresByPr100feadAfter
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Proveedores> findProveedoresByPr100feadAfter(java.util.Calendar pr100fead, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findProveedoresByPr100feadAfter", startResult, maxRows, pr100fead);
		return new LinkedHashSet<Proveedores>(query.getResultList());
	}

	/**
	 * JPQL Query - findProveedoresByPr100femoAfter
	 *
	 */
	@Override
	@Transactional
	public Set<Proveedores> findProveedoresByPr100femoAfter(java.util.Calendar pr100femo) throws DataAccessException {

		return findProveedoresByPr100femoAfter(pr100femo, -1, -1);
	}

	/**
	 * JPQL Query - findProveedoresByPr100femoAfter
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Proveedores> findProveedoresByPr100femoAfter(java.util.Calendar pr100femo, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findProveedoresByPr100femoAfter", startResult, maxRows, pr100femo);
		return new LinkedHashSet<Proveedores>(query.getResultList());
	}

	/**
	 * JPQL Query - findProveedoresByPr100copr
	 *
	 */
	@Override
	@Transactional
	public Set<Proveedores> findProveedoresByPr100copr(Integer pr100copr) throws DataAccessException {

		return findProveedoresByPr100copr(pr100copr, -1, -1);
	}

	/**
	 * JPQL Query - findProveedoresByPr100copr
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Proveedores> findProveedoresByPr100copr(Integer pr100copr, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findProveedoresByPr100copr", startResult, maxRows, pr100copr);
		return new LinkedHashSet<Proveedores>(query.getResultList());
	}

	/**
	 * JPQL Query - findProveedoresByPr100lomoContaining
	 *
	 */
	@Override
	@Transactional
	public Set<Proveedores> findProveedoresByPr100lomoContaining(String pr100lomo) throws DataAccessException {

		return findProveedoresByPr100lomoContaining(pr100lomo, -1, -1);
	}

	/**
	 * JPQL Query - findProveedoresByPr100lomoContaining
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Proveedores> findProveedoresByPr100lomoContaining(String pr100lomo, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findProveedoresByPr100lomoContaining", startResult, maxRows, pr100lomo);
		return new LinkedHashSet<Proveedores>(query.getResultList());
	}

	/**
	 * JPQL Query - findProveedoresByPr100lomo
	 *
	 */
	@Override
	@Transactional
	public Set<Proveedores> findProveedoresByPr100lomo(String pr100lomo) throws DataAccessException {

		return findProveedoresByPr100lomo(pr100lomo, -1, -1);
	}

	/**
	 * JPQL Query - findProveedoresByPr100lomo
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Proveedores> findProveedoresByPr100lomo(String pr100lomo, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findProveedoresByPr100lomo", startResult, maxRows, pr100lomo);
		return new LinkedHashSet<Proveedores>(query.getResultList());
	}

	/**
	 * JPQL Query - findProveedoresByPr100nomb
	 *
	 */
	@Override
	@Transactional
	public Set<Proveedores> findProveedoresByPr100nomb(String pr100nomb) throws DataAccessException {

		return findProveedoresByPr100nomb(pr100nomb, -1, -1);
	}

	/**
	 * JPQL Query - findProveedoresByPr100nomb
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Proveedores> findProveedoresByPr100nomb(String pr100nomb, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findProveedoresByPr100nomb", startResult, maxRows, pr100nomb);
		return new LinkedHashSet<Proveedores>(query.getResultList());
	}

	/**
	 * JPQL Query - findProveedoresByPr100femoBefore
	 *
	 */
	@Override
	@Transactional
	public Set<Proveedores> findProveedoresByPr100femoBefore(java.util.Calendar pr100femo) throws DataAccessException {

		return findProveedoresByPr100femoBefore(pr100femo, -1, -1);
	}

	/**
	 * JPQL Query - findProveedoresByPr100femoBefore
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Proveedores> findProveedoresByPr100femoBefore(java.util.Calendar pr100femo, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findProveedoresByPr100femoBefore", startResult, maxRows, pr100femo);
		return new LinkedHashSet<Proveedores>(query.getResultList());
	}

	/**
	 * JPQL Query - findProveedoresByPr100obs2Containing
	 *
	 */
	@Override
	@Transactional
	public Set<Proveedores> findProveedoresByPr100obs2Containing(String pr100obs2) throws DataAccessException {

		return findProveedoresByPr100obs2Containing(pr100obs2, -1, -1);
	}

	/**
	 * JPQL Query - findProveedoresByPr100obs2Containing
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Proveedores> findProveedoresByPr100obs2Containing(String pr100obs2, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findProveedoresByPr100obs2Containing", startResult, maxRows, pr100obs2);
		return new LinkedHashSet<Proveedores>(query.getResultList());
	}

	/**
	 * JPQL Query - findProveedoresByPr100cont
	 *
	 */
	@Override
	@Transactional
	public Set<Proveedores> findProveedoresByPr100cont(String pr100cont) throws DataAccessException {

		return findProveedoresByPr100cont(pr100cont, -1, -1);
	}

	/**
	 * JPQL Query - findProveedoresByPr100cont
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Proveedores> findProveedoresByPr100cont(String pr100cont, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findProveedoresByPr100cont", startResult, maxRows, pr100cont);
		return new LinkedHashSet<Proveedores>(query.getResultList());
	}

	/**
	 * JPQL Query - findProveedoresByPr100loadContaining
	 *
	 */
	@Override
	@Transactional
	public Set<Proveedores> findProveedoresByPr100loadContaining(String pr100load) throws DataAccessException {

		return findProveedoresByPr100loadContaining(pr100load, -1, -1);
	}

	/**
	 * JPQL Query - findProveedoresByPr100loadContaining
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Proveedores> findProveedoresByPr100loadContaining(String pr100load, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findProveedoresByPr100loadContaining", startResult, maxRows, pr100load);
		return new LinkedHashSet<Proveedores>(query.getResultList());
	}

	/**
	 * JPQL Query - findProveedoresByPrimaryKey
	 *
	 */
	@Override
	@Transactional
	public Proveedores findProveedoresByPrimaryKey(String pr100nocia, Integer pr100copr) throws DataAccessException {

		return findProveedoresByPrimaryKey(pr100nocia, pr100copr, -1, -1);
	}

	/**
	 * JPQL Query - findProveedoresByPrimaryKey
	 *
	 */

	@Override
	@Transactional
	public Proveedores findProveedoresByPrimaryKey(String pr100nocia, Integer pr100copr, int startResult, int maxRows) throws DataAccessException {
		try {
			Query query = createNamedQuery("findProveedoresByPrimaryKey", startResult, maxRows, pr100nocia, pr100copr);
			return (abs.domain.Proveedores) query.getSingleResult();
		} catch (NoResultException nre) {
			return null;
		}
	}

	/**
	 * JPQL Query - findProveedoresByPr100telf
	 *
	 */
	@Override
	@Transactional
	public Set<Proveedores> findProveedoresByPr100telf(String pr100telf) throws DataAccessException {

		return findProveedoresByPr100telf(pr100telf, -1, -1);
	}

	/**
	 * JPQL Query - findProveedoresByPr100telf
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Proveedores> findProveedoresByPr100telf(String pr100telf, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findProveedoresByPr100telf", startResult, maxRows, pr100telf);
		return new LinkedHashSet<Proveedores>(query.getResultList());
	}

	/**
	 * JPQL Query - findProveedoresByPr100obs
	 *
	 */
	@Override
	@Transactional
	public Set<Proveedores> findProveedoresByPr100obs(String pr100obs) throws DataAccessException {

		return findProveedoresByPr100obs(pr100obs, -1, -1);
	}

	/**
	 * JPQL Query - findProveedoresByPr100obs
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Proveedores> findProveedoresByPr100obs(String pr100obs, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findProveedoresByPr100obs", startResult, maxRows, pr100obs);
		return new LinkedHashSet<Proveedores>(query.getResultList());
	}

	/**
	 * JPQL Query - findProveedoresByPr100emai
	 *
	 */
	@Override
	@Transactional
	public Set<Proveedores> findProveedoresByPr100emai(String pr100emai) throws DataAccessException {

		return findProveedoresByPr100emai(pr100emai, -1, -1);
	}

	/**
	 * JPQL Query - findProveedoresByPr100emai
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Proveedores> findProveedoresByPr100emai(String pr100emai, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findProveedoresByPr100emai", startResult, maxRows, pr100emai);
		return new LinkedHashSet<Proveedores>(query.getResultList());
	}

	/**
	 * JPQL Query - findProveedoresByPr100tar
	 *
	 */
	@Override
	@Transactional
	public Set<Proveedores> findProveedoresByPr100tar(Integer pr100tar) throws DataAccessException {

		return findProveedoresByPr100tar(pr100tar, -1, -1);
	}

	/**
	 * JPQL Query - findProveedoresByPr100tar
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Proveedores> findProveedoresByPr100tar(Integer pr100tar, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findProveedoresByPr100tar", startResult, maxRows, pr100tar);
		return new LinkedHashSet<Proveedores>(query.getResultList());
	}

	/**
	 * JPQL Query - findProveedoresByPr100obsContaining
	 *
	 */
	@Override
	@Transactional
	public Set<Proveedores> findProveedoresByPr100obsContaining(String pr100obs) throws DataAccessException {

		return findProveedoresByPr100obsContaining(pr100obs, -1, -1);
	}

	/**
	 * JPQL Query - findProveedoresByPr100obsContaining
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Proveedores> findProveedoresByPr100obsContaining(String pr100obs, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findProveedoresByPr100obsContaining", startResult, maxRows, pr100obs);
		return new LinkedHashSet<Proveedores>(query.getResultList());
	}

	/**
	 * JPQL Query - findProveedoresByPr100nombContaining
	 *
	 */
	@Override
	@Transactional
	public Set<Proveedores> findProveedoresByPr100nombContaining(String pr100nomb) throws DataAccessException {

		return findProveedoresByPr100nombContaining(pr100nomb, -1, -1);
	}

	/**
	 * JPQL Query - findProveedoresByPr100nombContaining
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Proveedores> findProveedoresByPr100nombContaining(String pr100nomb, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findProveedoresByPr100nombContaining", startResult, maxRows, pr100nomb);
		return new LinkedHashSet<Proveedores>(query.getResultList());
	}

	/**
	 * JPQL Query - findProveedoresByPr100feadBefore
	 *
	 */
	@Override
	@Transactional
	public Set<Proveedores> findProveedoresByPr100feadBefore(java.util.Calendar pr100fead) throws DataAccessException {

		return findProveedoresByPr100feadBefore(pr100fead, -1, -1);
	}

	/**
	 * JPQL Query - findProveedoresByPr100feadBefore
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Proveedores> findProveedoresByPr100feadBefore(java.util.Calendar pr100fead, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findProveedoresByPr100feadBefore", startResult, maxRows, pr100fead);
		return new LinkedHashSet<Proveedores>(query.getResultList());
	}

	/**
	 * JPQL Query - findProveedoresByPr100ctacrContaining
	 *
	 */
	@Override
	@Transactional
	public Set<Proveedores> findProveedoresByPr100ctacrContaining(String pr100ctacr) throws DataAccessException {

		return findProveedoresByPr100ctacrContaining(pr100ctacr, -1, -1);
	}

	/**
	 * JPQL Query - findProveedoresByPr100ctacrContaining
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Proveedores> findProveedoresByPr100ctacrContaining(String pr100ctacr, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findProveedoresByPr100ctacrContaining", startResult, maxRows, pr100ctacr);
		return new LinkedHashSet<Proveedores>(query.getResultList());
	}

	/**
	 * JPQL Query - findProveedoresByPr100rucContaining
	 *
	 */
	@Override
	@Transactional
	public Set<Proveedores> findProveedoresByPr100rucContaining(String pr100ruc) throws DataAccessException {

		return findProveedoresByPr100rucContaining(pr100ruc, -1, -1);
	}

	/**
	 * JPQL Query - findProveedoresByPr100rucContaining
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Proveedores> findProveedoresByPr100rucContaining(String pr100ruc, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findProveedoresByPr100rucContaining", startResult, maxRows, pr100ruc);
		return new LinkedHashSet<Proveedores>(query.getResultList());
	}

	/**
	 * JPQL Query - findProveedoresByPr100ciud
	 *
	 */
	@Override
	@Transactional
	public Set<Proveedores> findProveedoresByPr100ciud(String pr100ciud) throws DataAccessException {

		return findProveedoresByPr100ciud(pr100ciud, -1, -1);
	}

	/**
	 * JPQL Query - findProveedoresByPr100ciud
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Proveedores> findProveedoresByPr100ciud(String pr100ciud, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findProveedoresByPr100ciud", startResult, maxRows, pr100ciud);
		return new LinkedHashSet<Proveedores>(query.getResultList());
	}

	/**
	 * JPQL Query - findProveedoresByPr100ruc
	 *
	 */
	@Override
	@Transactional
	public Set<Proveedores> findProveedoresByPr100ruc(String pr100ruc) throws DataAccessException {

		return findProveedoresByPr100ruc(pr100ruc, -1, -1);
	}

	/**
	 * JPQL Query - findProveedoresByPr100ruc
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Proveedores> findProveedoresByPr100ruc(String pr100ruc, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findProveedoresByPr100ruc", startResult, maxRows, pr100ruc);
		return new LinkedHashSet<Proveedores>(query.getResultList());
	}

	/**
	 * JPQL Query - findProveedoresByPr100emaiContaining
	 *
	 */
	@Override
	@Transactional
	public Set<Proveedores> findProveedoresByPr100emaiContaining(String pr100emai) throws DataAccessException {

		return findProveedoresByPr100emaiContaining(pr100emai, -1, -1);
	}

	/**
	 * JPQL Query - findProveedoresByPr100emaiContaining
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Proveedores> findProveedoresByPr100emaiContaining(String pr100emai, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findProveedoresByPr100emaiContaining", startResult, maxRows, pr100emai);
		return new LinkedHashSet<Proveedores>(query.getResultList());
	}

	/**
	 * JPQL Query - findProveedoresByPr100obs2
	 *
	 */
	@Override
	@Transactional
	public Set<Proveedores> findProveedoresByPr100obs2(String pr100obs2) throws DataAccessException {

		return findProveedoresByPr100obs2(pr100obs2, -1, -1);
	}

	/**
	 * JPQL Query - findProveedoresByPr100obs2
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Proveedores> findProveedoresByPr100obs2(String pr100obs2, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findProveedoresByPr100obs2", startResult, maxRows, pr100obs2);
		return new LinkedHashSet<Proveedores>(query.getResultList());
	}

	/**
	 * JPQL Query - findProveedoresByPr100direContaining
	 *
	 */
	@Override
	@Transactional
	public Set<Proveedores> findProveedoresByPr100direContaining(String pr100dire) throws DataAccessException {

		return findProveedoresByPr100direContaining(pr100dire, -1, -1);
	}

	/**
	 * JPQL Query - findProveedoresByPr100direContaining
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Proveedores> findProveedoresByPr100direContaining(String pr100dire, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findProveedoresByPr100direContaining", startResult, maxRows, pr100dire);
		return new LinkedHashSet<Proveedores>(query.getResultList());
	}

	/**
	 * JPQL Query - findProveedoresByPr100ctacr
	 *
	 */
	@Override
	@Transactional
	public Set<Proveedores> findProveedoresByPr100ctacr(String pr100ctacr) throws DataAccessException {

		return findProveedoresByPr100ctacr(pr100ctacr, -1, -1);
	}

	/**
	 * JPQL Query - findProveedoresByPr100ctacr
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Proveedores> findProveedoresByPr100ctacr(String pr100ctacr, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findProveedoresByPr100ctacr", startResult, maxRows, pr100ctacr);
		return new LinkedHashSet<Proveedores>(query.getResultList());
	}

	/**
	 * JPQL Query - findProveedoresByPr100contContaining
	 *
	 */
	@Override
	@Transactional
	public Set<Proveedores> findProveedoresByPr100contContaining(String pr100cont) throws DataAccessException {

		return findProveedoresByPr100contContaining(pr100cont, -1, -1);
	}

	/**
	 * JPQL Query - findProveedoresByPr100contContaining
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Proveedores> findProveedoresByPr100contContaining(String pr100cont, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findProveedoresByPr100contContaining", startResult, maxRows, pr100cont);
		return new LinkedHashSet<Proveedores>(query.getResultList());
	}

	/**
	 * JPQL Query - findProveedoresByPr100autoContaining
	 *
	 */
	@Override
	@Transactional
	public Set<Proveedores> findProveedoresByPr100autoContaining(String pr100auto) throws DataAccessException {

		return findProveedoresByPr100autoContaining(pr100auto, -1, -1);
	}

	/**
	 * JPQL Query - findProveedoresByPr100autoContaining
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Proveedores> findProveedoresByPr100autoContaining(String pr100auto, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findProveedoresByPr100autoContaining", startResult, maxRows, pr100auto);
		return new LinkedHashSet<Proveedores>(query.getResultList());
	}

	/**
	 * JPQL Query - findProveedoresByPrimaryKey
	 *
	 */
	@Transactional
	public Proveedores findProveedoresByPrimaryKey(Integer pr100copr) throws DataAccessException {

		return findProveedoresByPrimaryKey(pr100copr, -1, -1);
	}

	/**
	 * JPQL Query - findProveedoresByPrimaryKey
	 *
	 */

	@Transactional
	public Proveedores findProveedoresByPrimaryKey(Integer pr100copr, int startResult, int maxRows) throws DataAccessException {
		try {
			Query query = createNamedQuery("findProveedoresByPrimaryKey", startResult, maxRows, pr100copr);
			return (abs.domain.Proveedores) query.getSingleResult();
		} catch (NoResultException nre) {
			return null;
		}
	}

	/**
	 * JPQL Query - findProveedoresByPr100ctadbContaining
	 *
	 */
	@Override
	@Transactional
	public Set<Proveedores> findProveedoresByPr100ctadbContaining(String pr100ctadb) throws DataAccessException {

		return findProveedoresByPr100ctadbContaining(pr100ctadb, -1, -1);
	}

	/**
	 * JPQL Query - findProveedoresByPr100ctadbContaining
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Proveedores> findProveedoresByPr100ctadbContaining(String pr100ctadb, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findProveedoresByPr100ctadbContaining", startResult, maxRows, pr100ctadb);
		return new LinkedHashSet<Proveedores>(query.getResultList());
	}

	/**
	 * JPQL Query - findProveedoresByPr100nocia
	 *
	 */
	@Override
	@Transactional
	public Set<Proveedores> findProveedoresByPr100nocia(String pr100nocia) throws DataAccessException {

		return findProveedoresByPr100nocia(pr100nocia, -1, -1);
	}

	/**
	 * JPQL Query - findProveedoresByPr100nocia
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Proveedores> findProveedoresByPr100nocia(String pr100nocia, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findProveedoresByPr100nocia", startResult, maxRows, pr100nocia);
		return new LinkedHashSet<Proveedores>(query.getResultList());
	}

	/**
	 * JPQL Query - findProveedoresByPr100nociaContaining
	 *
	 */
	@Override
	@Transactional
	public Set<Proveedores> findProveedoresByPr100nociaContaining(String pr100nocia) throws DataAccessException {

		return findProveedoresByPr100nociaContaining(pr100nocia, -1, -1);
	}

	/**
	 * JPQL Query - findProveedoresByPr100nociaContaining
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Proveedores> findProveedoresByPr100nociaContaining(String pr100nocia, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findProveedoresByPr100nociaContaining", startResult, maxRows, pr100nocia);
		return new LinkedHashSet<Proveedores>(query.getResultList());
	}

	/**
	 * JPQL Query - findProveedoresByPr100dire
	 *
	 */
	@Override
	@Transactional
	public Set<Proveedores> findProveedoresByPr100dire(String pr100dire) throws DataAccessException {

		return findProveedoresByPr100dire(pr100dire, -1, -1);
	}

	/**
	 * JPQL Query - findProveedoresByPr100dire
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Proveedores> findProveedoresByPr100dire(String pr100dire, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findProveedoresByPr100dire", startResult, maxRows, pr100dire);
		return new LinkedHashSet<Proveedores>(query.getResultList());
	}

	/**
	 * JPQL Query - findProveedoresByPr100cgre
	 *
	 */
	@Override
	@Transactional
	public Set<Proveedores> findProveedoresByPr100cgre(String pr100cgre) throws DataAccessException {

		return findProveedoresByPr100cgre(pr100cgre, -1, -1);
	}

	/**
	 * JPQL Query - findProveedoresByPr100cgre
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Proveedores> findProveedoresByPr100cgre(String pr100cgre, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findProveedoresByPr100cgre", startResult, maxRows, pr100cgre);
		return new LinkedHashSet<Proveedores>(query.getResultList());
	}

	/**
	 * JPQL Query - findProveedoresByPr100rele
	 *
	 */
	@Override
	@Transactional
	public Set<Proveedores> findProveedoresByPr100rele(String pr100rele) throws DataAccessException {

		return findProveedoresByPr100rele(pr100rele, -1, -1);
	}

	/**
	 * JPQL Query - findProveedoresByPr100rele
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Proveedores> findProveedoresByPr100rele(String pr100rele, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findProveedoresByPr100rele", startResult, maxRows, pr100rele);
		return new LinkedHashSet<Proveedores>(query.getResultList());
	}

	/**
	 * JPQL Query - findProveedoresByPr100auto
	 *
	 */
	@Override
	@Transactional
	public Set<Proveedores> findProveedoresByPr100auto(String pr100auto) throws DataAccessException {

		return findProveedoresByPr100auto(pr100auto, -1, -1);
	}

	/**
	 * JPQL Query - findProveedoresByPr100auto
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Proveedores> findProveedoresByPr100auto(String pr100auto, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findProveedoresByPr100auto", startResult, maxRows, pr100auto);
		return new LinkedHashSet<Proveedores>(query.getResultList());
	}

	/**
	 * JPQL Query - findProveedoresByPr100load
	 *
	 */
	@Override
	@Transactional
	public Set<Proveedores> findProveedoresByPr100load(String pr100load) throws DataAccessException {

		return findProveedoresByPr100load(pr100load, -1, -1);
	}

	/**
	 * JPQL Query - findProveedoresByPr100load
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Proveedores> findProveedoresByPr100load(String pr100load, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findProveedoresByPr100load", startResult, maxRows, pr100load);
		return new LinkedHashSet<Proveedores>(query.getResultList());
	}

	/**
	 * JPQL Query - findProveedoresByPr100ciudContaining
	 *
	 */
	@Override
	@Transactional
	public Set<Proveedores> findProveedoresByPr100ciudContaining(String pr100ciud) throws DataAccessException {

		return findProveedoresByPr100ciudContaining(pr100ciud, -1, -1);
	}

	/**
	 * JPQL Query - findProveedoresByPr100ciudContaining
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Proveedores> findProveedoresByPr100ciudContaining(String pr100ciud, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findProveedoresByPr100ciudContaining", startResult, maxRows, pr100ciud);
		return new LinkedHashSet<Proveedores>(query.getResultList());
	}

	/**
	 * JPQL Query - findProveedoresByPr100femo
	 *
	 */
	@Override
	@Transactional
	public Set<Proveedores> findProveedoresByPr100femo(java.util.Calendar pr100femo) throws DataAccessException {

		return findProveedoresByPr100femo(pr100femo, -1, -1);
	}

	/**
	 * JPQL Query - findProveedoresByPr100femo
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Proveedores> findProveedoresByPr100femo(java.util.Calendar pr100femo, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findProveedoresByPr100femo", startResult, maxRows, pr100femo);
		return new LinkedHashSet<Proveedores>(query.getResultList());
	}

	/**
	 * JPQL Query - findProveedoresByPr100cgreContaining
	 *
	 */
	@Override
	@Transactional
	public Set<Proveedores> findProveedoresByPr100cgreContaining(String pr100cgre) throws DataAccessException {

		return findProveedoresByPr100cgreContaining(pr100cgre, -1, -1);
	}

	/**
	 * JPQL Query - findProveedoresByPr100cgreContaining
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Proveedores> findProveedoresByPr100cgreContaining(String pr100cgre, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findProveedoresByPr100cgreContaining", startResult, maxRows, pr100cgre);
		return new LinkedHashSet<Proveedores>(query.getResultList());
	}

	/**
	 * JPQL Query - findProveedoresByPr100telfContaining
	 *
	 */
	@Override
	@Transactional
	public Set<Proveedores> findProveedoresByPr100telfContaining(String pr100telf) throws DataAccessException {

		return findProveedoresByPr100telfContaining(pr100telf, -1, -1);
	}

	/**
	 * JPQL Query - findProveedoresByPr100telfContaining
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Proveedores> findProveedoresByPr100telfContaining(String pr100telf, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findProveedoresByPr100telfContaining", startResult, maxRows, pr100telf);
		return new LinkedHashSet<Proveedores>(query.getResultList());
	}

	/**
	 * JPQL Query - findProveedoresByPr100fead
	 *
	 */
	@Override
	@Transactional
	public Set<Proveedores> findProveedoresByPr100fead(java.util.Calendar pr100fead) throws DataAccessException {

		return findProveedoresByPr100fead(pr100fead, -1, -1);
	}

	/**
	 * JPQL Query - findProveedoresByPr100fead
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Proveedores> findProveedoresByPr100fead(java.util.Calendar pr100fead, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findProveedoresByPr100fead", startResult, maxRows, pr100fead);
		return new LinkedHashSet<Proveedores>(query.getResultList());
	}

	/**
	 * JPQL Query - findProveedoresByPr100releContaining
	 *
	 */
	@Override
	@Transactional
	public Set<Proveedores> findProveedoresByPr100releContaining(String pr100rele) throws DataAccessException {

		return findProveedoresByPr100releContaining(pr100rele, -1, -1);
	}

	/**
	 * JPQL Query - findProveedoresByPr100releContaining
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Proveedores> findProveedoresByPr100releContaining(String pr100rele, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findProveedoresByPr100releContaining", startResult, maxRows, pr100rele);
		return new LinkedHashSet<Proveedores>(query.getResultList());
	}

	/**
	 * JPQL Query - findProveedoresByPr100plaz
	 *
	 */
	@Override
	@Transactional
	public Set<Proveedores> findProveedoresByPr100plaz(Integer pr100plaz) throws DataAccessException {

		return findProveedoresByPr100plaz(pr100plaz, -1, -1);
	}

	/**
	 * JPQL Query - findProveedoresByPr100plaz
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Proveedores> findProveedoresByPr100plaz(Integer pr100plaz, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findProveedoresByPr100plaz", startResult, maxRows, pr100plaz);
		return new LinkedHashSet<Proveedores>(query.getResultList());
	}

	/**
	 * JPQL Query - findProveedoresByPr100ctadb
	 *
	 */
	@Override
	@Transactional
	public Set<Proveedores> findProveedoresByPr100ctadb(String pr100ctadb) throws DataAccessException {

		return findProveedoresByPr100ctadb(pr100ctadb, -1, -1);
	}

	/**
	 * JPQL Query - findProveedoresByPr100ctadb
	 *
	 */

	@Override
	@SuppressWarnings("unchecked")
	@Transactional
	public Set<Proveedores> findProveedoresByPr100ctadb(String pr100ctadb, int startResult, int maxRows) throws DataAccessException {
		Query query = createNamedQuery("findProveedoresByPr100ctadb", startResult, maxRows, pr100ctadb);
		return new LinkedHashSet<Proveedores>(query.getResultList());
	}

	/**
	 * Used to determine whether or not to merge the entity or persist the entity when calling Store
	 * @see store
	 * 
	 *
	 */
	@Override
	public boolean canBeMerged(Proveedores entity) {
		return true;
	}
}
